home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / MacGofer 0.22d / MacGofer Sources / mac_menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-24  |  21.9 KB  |  971 lines  |  [TEXT/MPS ]
  1. /*****************************************************************************
  2.  
  3.   mac_menu.c:  Copyright (c) Kevin Hammond 1993.   All rights reserved.
  4.   
  5.   This module contains menu-handling code. 
  6.  
  7. *****************************************************************************/
  8.  
  9. #include "mac.h"
  10. #include <Balloons.h>
  11.  
  12. #pragma segment Menus
  13.  
  14. typedef void  (* cfunc) (short);
  15.  
  16.  
  17. extern Boolean copyscrap;    /* Whether the scrap must be copied  */
  18.  
  19. /* Menu Handles */
  20.  
  21. MenuHandle Menu_Apple, Menu_File, Menu_Edit, Menu_Find, 
  22.            Menu_Font, Menu_Option, Menu_Window, Menu_Project;
  23.            
  24. extern Boolean closethewindow();
  25.  
  26.  
  27. /*
  28.     The Apple Menu.
  29. */
  30.  
  31. void DoMenuApple(item,modifiers)
  32. short   item;
  33. short    modifiers;
  34. {
  35.   switch (item)
  36.     {
  37.       case MItem_About_Gofer:            /* The About Gofer dialog. */
  38.         {
  39.       char s[11];
  40.       long freemem, dummy;
  41.       (void) MaxMem(&dummy);
  42.       freemem = FreeMem();
  43.       sprintf(s,"%lu",freemem/1024);
  44.       paramtext(GoferVersionString,s,"","");
  45.           Alert(Res_About_Gofer_Alert,NIL);
  46.     }
  47.     break;
  48.  
  49.       /* Other Apple Menu items */
  50.       default:
  51.     {
  52.       Str255  DAName;
  53.       GrafPtr  SavePort;
  54.  
  55.       GetPort(&SavePort);            /* save the current grafport */
  56.       GetItem(Menu_Apple, item, DAName);
  57.       OpenDeskAcc(DAName);
  58.       SetPort(SavePort);            /* restore it after opening DAs */
  59.     }
  60.         break;
  61.     }
  62. }
  63.  
  64.  
  65.  
  66. /*
  67.     The File Menu.
  68. */
  69.  
  70. void DoMenuFile(item,modifiers)
  71. short item;
  72. short    modifiers;
  73. {
  74.   thefrontwindow = findMyWindow(FrontWindow());
  75.   
  76.   cantundo();
  77.  
  78.   switch (item) {                      
  79.     case MItem_New:
  80.       CheckMemory("New Window",2048 /* Guess */);
  81.       newUntitledWindow();                 /* New window */
  82.       break;
  83.  
  84.     case MItem_Open:
  85.       Open_The_File();                     /* Open a file */
  86.       break;
  87.  
  88.     case MItem_Close:
  89.       if(thefrontwindow == ILLEGAL_WINDOW)
  90.         CloseDeskAcc(((WindowPeek)FrontWindow())->windowKind);
  91.       else
  92.         if(closethewindow(thefrontwindow,"closing"))
  93.       ;   /* Close a window */
  94.       break;
  95.  
  96.     case MItem_Save:
  97.       save(thefrontwindow);                /* Save a window */
  98.       break;
  99.  
  100.     case MItem_Save_As:
  101.       saveas(thefrontwindow);              /* Save with prompt */
  102.       break;
  103.  
  104.     case MItem_Save_A_Copy:
  105.       saveacopy(thefrontwindow);           /* Save without changing filename */
  106.       break;
  107.  
  108.     case MItem_Revert_to_Saved:
  109.       revert(thefrontwindow);              /* Restore old version */
  110.       break;
  111.  
  112.     case MItem_Delete:
  113.       dodelete(thefrontwindow);            /* Delete Files */
  114.       break;
  115.  
  116.     case MItem_Page_Setup:
  117.       PageSetup();                         /* Page setup for the printer */
  118.       break;
  119.  
  120.     case MItem_Print:
  121.       Print_Window(thefrontwindow);        /* Print the window on the printer */
  122.       break;
  123.  
  124.     case MItem_Quit:
  125.       (void) QuitApp(kAEAskUser);          /* Quit */
  126.        break;
  127.  
  128.     default:
  129.       break;
  130.     }
  131. }
  132.  
  133. /*
  134.       The Edit menu.
  135. */
  136.  
  137. void DoMenuEdit(item,modifiers)
  138. short    item;
  139. short    modifiers;
  140. {
  141.   /* Allow DAs to handle their own edits */
  142.  
  143.   if  (!SystemEdit(item-1))
  144.     {
  145.       thefrontwindow = findMyWindow(FrontWindow());
  146.   
  147.       switch (item)
  148.     {
  149.           case MItem_Undo:            /* Undo */
  150.         undo(thefrontwindow);
  151.         break;
  152.  
  153.       case MItem_Cut:            /* Cut */
  154.         if(isEditWindow(thefrontwindow))
  155.           {
  156.             TEHandle teh = TEHANDLE(thefrontwindow);
  157.             int memneeded = ((*teh)->selEnd - (*teh)->selStart)*2+4096; 
  158.                 CheckMemory("Cut",memneeded);
  159.         changed(thefrontwindow);
  160.         saveundo(thefrontwindow);
  161.         if(thefrontwindow == worksheet)
  162.           AdjustPromptCount(TRUE);
  163.         TECut(teh);
  164.                 copyscrap = TRUE;
  165.         /* HSL: 7/23/92 -- we need to copy the TextEdit scrap to the System scrap */
  166.         doscrap();
  167.         AdjustScrollBars(thefrontwindow);
  168.         ScrollToSelection(thefrontwindow);
  169.           }
  170.         else
  171.           SysBeep(1);
  172.         break;
  173.  
  174.       case MItem_Copy:        /* Copy */
  175.         if(isEditWindow(thefrontwindow))
  176.           {
  177.             TEHandle teh = TEHANDLE(thefrontwindow);
  178.             int memneeded = (*teh)->selEnd - (*teh)->selStart+512; 
  179.                 CheckMemory("Copy",memneeded);
  180.         TECopy(teh);
  181.                 copyscrap = TRUE;
  182.         doscrap();
  183.         cantundo();
  184.               }
  185.         else
  186.           SysBeep(1);
  187.         break;
  188.  
  189.       case MItem_Paste:        /* Paste */
  190.         if(isEditWindow(thefrontwindow))
  191.           {
  192.             TEHandle teh = TEHANDLE(thefrontwindow);
  193.             if((long) (*teh)->teLength + TEGetScrapLen() > TE_REC_SIZE)
  194.           Error("","Clipboard too large to paste into window");
  195.         else
  196.           {
  197.                     CheckMemory("Paste",(TEGetScrapLen()+(*teh)->selEnd-(*teh)->selStart)*2+512);
  198.             changed(thefrontwindow);
  199.             /* Was keyundo, but this conflates pasting/typing */
  200.             pasteundo(thefrontwindow);
  201.  
  202.             if(thefrontwindow == worksheet)
  203.               {
  204.                 AdjustPromptCount(TRUE);
  205.                 TEPaste(TEHANDLE(thefrontwindow));
  206.                 AdjustPromptCount(FALSE);
  207.                 PasteInput();
  208.               }
  209.             else
  210.               TEPaste(TEHANDLE(thefrontwindow));
  211.             AdjustScrollBars(thefrontwindow);
  212.             ScrollToSelection(thefrontwindow);
  213.               }
  214.           }
  215.         else
  216.           SysBeep(1);
  217.         break;
  218.         
  219.       case MItem_Clear:        /* Clear */
  220.         if(isEditWindow(thefrontwindow))
  221.           {
  222.         changed(thefrontwindow);
  223.         saveundo(thefrontwindow);
  224.         if(thefrontwindow == worksheet)
  225.           AdjustPromptCount(TRUE);
  226.         TEDelete(TEHANDLE(thefrontwindow));
  227.         AdjustScrollBars(thefrontwindow);
  228.         ScrollToSelection(thefrontwindow);
  229.           }
  230.         break;
  231.         
  232.       case MItem_Select_All:    /* Select All */
  233.         if(isEditWindow(thefrontwindow))
  234.           {
  235.             /* Can't undo select all */
  236.             cantundo();
  237.             TESetSelect(0,32767,TEHANDLE(thefrontwindow));
  238.           }
  239.         break;
  240.  
  241.       case MItem_Show_Clipboard:    /* Show/Hide Clipboard */
  242.         showhideclipboard();
  243.         break;
  244.  
  245.       default:
  246.         break;
  247.        }
  248.    }
  249. }
  250.  
  251.  
  252.  
  253. /*
  254.       The Find menu.
  255. */
  256.  
  257. void DoMenuFind(item,modifiers)
  258. short    item;
  259. short    modifiers;
  260. {
  261.   thefrontwindow = findMyWindow(FrontWindow());
  262.   
  263.   /* Can't undo searches */
  264.   cantundo();
  265.   
  266.   if(item <= MItem_Goto_Line && iconic(thefrontwindow))
  267.     DeIconiseWindow(thefrontwindow);
  268.  
  269.   switch (item) 
  270.     {
  271.       case MItem_Find_Replace:
  272.         dofind(thefrontwindow);
  273.         break;
  274.       
  275.       case MItem_Find_Again:
  276.         dofindagain(thefrontwindow);
  277.     break;
  278.     
  279.       case MItem_Find_Backwards:
  280.         dofindbackwards(thefrontwindow);
  281.     break;
  282.     
  283.       case MItem_Replace_Again:
  284.         doreplaceagain(thefrontwindow);
  285.     break;
  286.  
  287.       case MItem_Goto_Line:
  288.         {
  289.       int line = numdialog(Res_Dlg_Goto_Line,Res_DItem_Goto,1,1,32767);
  290.       if(line > 0)
  291.         findLine(thefrontwindow,line);
  292.     }
  293.     break;
  294.     
  295.       case MItem_Defn_Name:
  296.         CheckMemory("Definition",32767 /* guess */);
  297.         dofinddefn();
  298.     break;
  299.  
  300.       case MItem_Defn_Names:
  301.         CheckMemory("Definitions",32767 /* guess */);
  302.         dofinddefns();
  303.     break;
  304.     
  305.       case MItem_Defn_Type:
  306.         CheckMemory("Type", 32767 /* guess */);
  307.         dofindtype();
  308.     break;
  309.  
  310.       case MItem_Defn_Types:
  311.         CheckMemory("Types", 32767 /* guess */);
  312.         dofindtypedefn();
  313.     break;
  314.  
  315.       case MItem_Find_Error:
  316.         CheckMemory("Find Error",1024 /* guess */);
  317.     findError();
  318.         break;
  319.     
  320.       default:
  321.     break;
  322.     }
  323. }
  324.  
  325.  
  326. /* The standard font sizes */
  327.  
  328. static short FSizes[] = {9,10,12,14};
  329. #define NUM_FONTSIZES (sizeof(FSizes)/sizeof(short))
  330.  
  331. /* Initial font settings for new windows */
  332. short currentfnum = monaco;
  333. short currentfsize = 9;
  334.  
  335. /* The other font sizes dialog -- return 0 for failure */
  336. short dodlgfontsize()
  337. {
  338.   static int lastsize = 18;
  339.   int new = numdialog(Res_Dlg_Other_Size,Res_DItem_Other_Size,lastsize,6,100);
  340.   if (new > 0)
  341.     lastsize = new;
  342.  
  343.   return(new);
  344. }
  345.  
  346.  
  347.  
  348. /*
  349.   Update the front window to reflect a font change.
  350. */
  351.  
  352. void updateFont(windex,fontnum,fontsize)
  353. int windex;
  354. short fontnum;
  355. short fontsize;
  356. {
  357.   if(windex != ILLEGAL_WINDOW && TEHANDLE(windex)!=NIL)
  358.     {
  359.       Rect pr = WINDOW(windex)->portRect;
  360.       
  361.       TEHandle teh = TEHANDLE(windex);
  362.       short topchar;
  363.       FontInfo fontinfo;
  364.  
  365.       Boolean saveLock;
  366.       GrafPtr saveport;
  367.  
  368.       CheckMemory("Change Font",2048 /* guess */);
  369.       
  370.       /* Prepare to start fiddling */
  371.       GetPort(&saveport);
  372.       SetPort(WINDOW(windex));
  373.       SafeHLock((Handle)teh, &saveLock);
  374.       topchar = (*teh)->lineStarts[GetCtlValue(VSCROLL(windex)) - 1];
  375.  
  376.       /* Invalidate the old viewrect */
  377.       EraseRect(&(*teh)->viewRect);
  378.       InvalRect(&(*teh)->viewRect);
  379.  
  380.       /* Set new font number info */
  381.       if (fontnum >= 0)
  382.         {
  383.       TextFont(fontnum);
  384.       (*teh)->txFont = fontnum;
  385.     }
  386.  
  387.       /* Set new font size info */
  388.       if (fontsize >= 0)
  389.         {
  390.       TextSize(fontsize);
  391.       (*teh)->txSize = fontsize;
  392.     }
  393.  
  394.       /* Request font info so we can install values into TE record */
  395.       GetFontInfo(&fontinfo);
  396.       (*teh)->fontAscent = fontinfo.ascent;
  397.       (*teh)->lineHeight = fontinfo.ascent + fontinfo.descent + fontinfo.leading;
  398.  
  399.       /* Compute new rects */
  400.       CalculateTERects(&(*teh)->viewRect, &(*teh)->destRect, (*teh)->lineHeight, windex == worksheet);
  401.  
  402.       /* Notify TE and our support systems */
  403.       TECalText(teh);
  404.       AdjustScrollBars(windex);
  405.       ScrollCharacter(windex,topchar,FALSE);
  406.  
  407.       /* We're done */
  408.       SafeHUnlock((Handle)teh, saveLock);
  409.       SetPort(saveport);
  410.     }
  411. }
  412.  
  413. /*
  414.       The Font Menu.
  415. */
  416.  
  417. void DoMenuFont(item,modifiers)
  418. short    item;
  419. short    modifiers;
  420. {
  421.   thefrontwindow = findMyWindow(FrontWindow());
  422.   
  423.   if (item < MItem_Font_Others)
  424.     {
  425.       setfontsize(FSizes[item-1]);
  426.       updateFont(thefrontwindow,-1,FSizes[item-1]);
  427.     }
  428.  
  429.   else if (item == MItem_Font_Others)
  430.     {
  431.       int newsize;
  432.       
  433.       /* If not cancelled, update the font size */
  434.       if ((newsize = dodlgfontsize()) > 0)
  435.         {
  436.           setfontsize(newsize);
  437.           updateFont(thefrontwindow,-1,newsize);
  438.     }
  439.       else
  440.         return;
  441.     }
  442.  
  443.   else if (item >= MItem_Font_Base)
  444.     {
  445.       setnewfont(item,"");
  446.       updateFont(thefrontwindow,currentfnum,-1);
  447.     }
  448.  
  449.   /* Can't currently undo; should really be able to */
  450.   cantundo();
  451. }
  452.  
  453.  
  454.  
  455.  
  456.  
  457. /*
  458.   Set a new font for the current port.
  459.   Either item or fname can be used to specify the font.
  460. */
  461.  
  462. setnewfont(item,fname)
  463. short item; char *fname;
  464. {
  465.   static oldfitem = 0;
  466.   char font[256];
  467.  
  468.   if(item <= 0)
  469.     {
  470.       short fonts = CountMItems(Menu_Font);
  471.       short i;
  472.       
  473.       for (i=MItem_Font_Base; i <= fonts; ++i)
  474.         {
  475.           getitem(Menu_Font,i,font);
  476.       
  477.           if(strcmp(font,fname)==0)
  478.         break;
  479.     }
  480.  
  481.       if(i > fonts)
  482.         {
  483.           Error("Internal ","the selected font cannot be found");
  484.           for (i=MItem_Font_Base; i <= fonts; ++i)
  485.             {
  486.               getitem(Menu_Font,i,font);
  487.       
  488.               if(strcmp(font,"Monaco")==0)
  489.             break;
  490.         }
  491.     }
  492.       item = i;
  493.     }
  494.   else
  495.     getitem(Menu_Font,item,font);
  496.  
  497.   if (oldfitem >= 1)
  498.     CheckItem(Menu_Font,oldfitem,FALSE);
  499.  
  500.   CheckItem(Menu_Font,item,TRUE);
  501.   oldfitem = item;
  502.   
  503.   getfnum(font,¤tfnum);
  504.   
  505.   outlinefontsizes(currentfnum);
  506. }
  507.  
  508.  
  509. /*
  510.   Set the size of the font in the front window.
  511. */
  512.  
  513. setfontsize(size)
  514. short size;
  515. {
  516.   short i;
  517.  
  518.   /* Check the size if it's one of the standard ones */
  519.   for(i=0;i<NUM_FONTSIZES;++i)
  520.     CheckItem(Menu_Font,i+1,FSizes[i]==size);
  521.  
  522.   currentfsize = size;
  523. }
  524.  
  525.  
  526.  
  527. /*
  528.   Outline the font sizes available for the currently
  529.   selected font.
  530. */
  531.  
  532.  
  533. outlinefontsizes(fnum)
  534. short fnum;
  535. {
  536.   short i;
  537.   
  538.   for(i=0; i < NUM_FONTSIZES; ++i)
  539.     SetItemStyle(Menu_Font,i+1,RealFont(fnum,FSizes[i])?outline:normal);
  540. }
  541.  
  542.  
  543.  
  544. /*
  545.       The Options menu.
  546. */
  547.  
  548. void DoMenuOption(item,modifiers)
  549. short    item;
  550. short    modifiers;
  551. {
  552.   extern Boolean HiddenPrefsChanged;
  553.  
  554.   cantundo();
  555.   
  556.   if (item <= Option_Toggle_Limit)
  557.     dotoggle(item);
  558.  
  559.   else switch (item) 
  560.     {
  561.       case MItem_Heap:
  562.           domemorydialog();
  563.     HiddenPrefsChanged = TRUE;
  564.     break;
  565.  
  566.       case MItem_Evidence:
  567.         doevidencedialog();
  568.     HiddenPrefsChanged = TRUE;
  569.     break;
  570.     
  571.       case MItem_Arcana:
  572.         doarcanadialog();
  573.     HiddenPrefsChanged = TRUE;
  574.     break;
  575.         
  576.       case MItem_Save_Prefs:
  577.         SavePrefs();
  578.         break;
  579.     }
  580. }
  581.  
  582.  
  583. /*
  584.       The window menu.
  585. */
  586.  
  587.  
  588. void DoMenuWindow(item,modifiers)
  589. short    item;
  590. short    modifiers;
  591. {
  592.   cantundo();
  593.   switch (item) 
  594.     { 
  595.       case MItem_Help:
  596.         Alert(Res_Help_Alert,NIL);
  597.     break;
  598.  
  599.       case MItem_Iconise:
  600.         {
  601.        int windex = findMyWindow(FrontWindow());
  602.  
  603.        if(modifiers & optionKey)
  604.               IconiseAll();
  605.  
  606.            else if(iconic(windex))
  607.              DeIconiseWindow(windex);
  608.  
  609.            else
  610.              IconiseWindow(windex);
  611.      }
  612.          break;
  613.       
  614.       /* Open the window corresponding to this item */
  615.       default:
  616.     {
  617.       char windowname[256];
  618.       getitem(Menu_Window,item,windowname);
  619.       openwindowcalled(windowname);
  620.     }
  621.     break;
  622.     }
  623. }
  624.  
  625.  
  626.  
  627. /*
  628.       The Project menu.
  629. */
  630.  
  631. void DoMenuProject(item,modifiers) 
  632. short    item;
  633. short    modifiers;
  634. {
  635.   cantundo();
  636.   switch (item) 
  637.     {
  638.       case MItem_Clear_Project:
  639.         clearProject();
  640.     break;
  641.  
  642.       case MItem_Open_Project:
  643.     openProject();
  644.     break;
  645.  
  646.       case MItem_Save_Project:
  647.     saveProject();
  648.     break;
  649.  
  650.       case MItem_Save_Project_As:
  651.     saveProjectAs();
  652.     break;
  653.  
  654.       case MItem_Load_File:
  655.     loadProjectFile();
  656.     break;
  657.  
  658.       case MItem_Unload_File:
  659.     unloadProjectFile();
  660.     break;
  661.  
  662.       case MItem_Reload:
  663.         reloadProjectFiles();
  664.     break;
  665.  
  666.       case MItem_Reorder:
  667.         rearrangeProjectFiles();
  668.     break;
  669.  
  670.       default:
  671.     findProjectFile(item);
  672.     break;
  673.     }
  674. }
  675.  
  676.  
  677.  
  678. /* HSL: 7/6/92, 7/7/92, 7/8/92, 7/25/92 -- certain commands should be enabled and disabled dynamically */
  679. void AdjustMenus(activate)
  680. Boolean activate;
  681. {
  682.    extern Boolean running_interpreter;
  683.    extern int MultiTasking;
  684.    
  685.    if(thefrontwindow == ILLEGAL_WINDOW)
  686.      {
  687.        if(!activate)
  688.          return;
  689.  
  690.        /* Disable the non-edit, non-file menus */
  691.        disablemenuitem(true,Menu_Find,0);
  692.        disablemenuitem(true,Menu_Font,0);
  693.        disablemenuitem(true,Menu_Option,0);
  694.        disablemenuitem(true,Menu_Window,0);
  695.        disablemenuitem(true,Menu_Project,0);
  696.  
  697.        /* Enable the standard edit menu items */
  698.        disablemenuitem(false,Menu_Edit,MItem_Undo);
  699.        disablemenuitem(false,Menu_Edit,MItem_Copy);
  700.        disablemenuitem(false,Menu_Edit,MItem_Cut);
  701.        disablemenuitem(false,Menu_Edit,MItem_Clear);
  702.        disablemenuitem(false,Menu_Edit,MItem_Paste);
  703.        disablemenuitem(true,Menu_Edit,MItem_Select_All);
  704.        disablemenuitem(true,Menu_Edit,MItem_Show_Clipboard);
  705.        setitem(Menu_Edit,MItem_Undo,"Undo");
  706.        
  707.        /* Enable the standard File menu items */
  708.        disablemenuitem(false,Menu_File,MItem_New);
  709.        disablemenuitem(false,Menu_File,MItem_Open);
  710.        disablemenuitem(false,Menu_File,MItem_Close);
  711.        
  712.        /* And Disable the rest */
  713.        disablemenuitem(true,Menu_File,MItem_Save);
  714.        disablemenuitem(true,Menu_File,MItem_Save_As);
  715.        disablemenuitem(true,Menu_File,MItem_Revert_to_Saved);
  716.        disablemenuitem(true,Menu_File,MItem_Delete);
  717.        disablemenuitem(true,Menu_File,MItem_Page_Setup);
  718.        disablemenuitem(true,Menu_File,MItem_Print);
  719.  
  720.        /* Now refresh the menu bar */
  721.        DrawMenuBar();
  722.      }
  723.    else
  724.      {
  725.        if(activate)
  726.          {
  727.            Boolean evaluating = running_interpreter && !MultiTasking;
  728.  
  729.            /* Reset the standard menus unless we're evaluating */
  730.        disablemenuitem(evaluating,Menu_File,0);
  731.        disablemenuitem(evaluating,Menu_Edit,0);
  732.            disablemenuitem(evaluating,Menu_Find,0);
  733.            disablemenuitem(evaluating,Menu_Font,0);
  734.            disablemenuitem(evaluating,Menu_Option,0);
  735.            disablemenuitem(evaluating,Menu_Window,0);
  736.            disablemenuitem(evaluating,Menu_Project,0);
  737.            disablemenuitem(evaluating,Menu_Edit,MItem_Show_Clipboard);
  738.            setitem(Menu_Edit,MItem_Undo,"Can't Undo");
  739.            disablemenuitem(true,Menu_Edit,MItem_Undo);
  740.  
  741.            /* And the standard file options */
  742.            disablemenuitem(false,Menu_File,MItem_Save);
  743.            disablemenuitem(false,Menu_File,MItem_Save_As);
  744.            disablemenuitem(false,Menu_File,MItem_Revert_to_Saved);
  745.            disablemenuitem(false,Menu_File,MItem_Delete);
  746.            disablemenuitem(false,Menu_File,MItem_Page_Setup);
  747.            disablemenuitem(false,Menu_File,MItem_Print);
  748.  
  749.            /* Now refresh the menu bar */
  750.            DrawMenuBar();
  751.      }
  752.      
  753.        if(activate || running_interpreter)
  754.          {
  755.            /* Disable project items if running the interpreter */
  756.            disablemenuitem(running_interpreter,Menu_Project,MItem_Clear_Project);
  757.            disablemenuitem(running_interpreter,Menu_Project,MItem_Open_Project);
  758.            disablemenuitem(running_interpreter,Menu_Project,MItem_Save_Project);
  759.            disablemenuitem(running_interpreter,Menu_Project,MItem_Save_Project_As);
  760.            disablemenuitem(running_interpreter,Menu_Project,MItem_Load_File);
  761.            disablemenuitem(running_interpreter || CountMItems(Menu_Project) == PreludeItem,
  762.                            Menu_Project,MItem_Unload_File);
  763.            disablemenuitem(running_interpreter,Menu_Project,MItem_Reload);
  764.            disablemenuitem(running_interpreter || CountMItems(Menu_Project) < PreludeItem + 2,
  765.                            Menu_Project,MItem_Reorder);
  766.      }
  767.  
  768.         if (isEditWindow(thefrontwindow))
  769.          {
  770.        /* Set up edit window menus */
  771.            TEHandle teh = TEHANDLE(thefrontwindow);
  772.            Boolean noSelection = (**teh).selStart == (**teh).selEnd;
  773.            long dummyOffset;
  774.            Boolean noScrap = GetScrap(NULL, 'TEXT', &dummyOffset) <= 0; 
  775.  
  776.            disablemenuitem(noSelection,Menu_Edit,MItem_Copy);
  777.            disablemenuitem(noSelection,Menu_Edit,MItem_Cut);
  778.            disablemenuitem(noSelection,Menu_Edit,MItem_Clear);
  779.            disablemenuitem(noScrap,Menu_Edit,MItem_Paste);
  780.            disablemenuitem(false,Menu_Edit,MItem_Select_All);
  781.  
  782.        /* Set the save and save as menus */
  783.            disablemenuitem(SAVED(thefrontwindow),Menu_File,MItem_Save);
  784.            disablemenuitem(VIRGIN(thefrontwindow),Menu_File,MItem_Revert_to_Saved);
  785.          }
  786.  
  787.        else if (activate)
  788.          {
  789.             disablemenuitem(true,Menu_Edit,MItem_Cut);
  790.             disablemenuitem(true,Menu_Edit,MItem_Copy);
  791.             disablemenuitem(true,Menu_Edit,MItem_Paste);
  792.             disablemenuitem(true,Menu_Edit,MItem_Clear);
  793.             disablemenuitem(true,Menu_Edit,MItem_Select_All);
  794.  
  795.             disablemenuitem(!iconic(thefrontwindow),Menu_File,MItem_Save);
  796.             disablemenuitem(!iconic(thefrontwindow),Menu_File,MItem_Save_As);
  797.             disablemenuitem(!iconic(thefrontwindow),Menu_File,MItem_Revert_to_Saved);
  798.          }
  799.     }
  800. }
  801.  
  802.  
  803.  
  804. /*
  805.     Disable/enable all menus.
  806. */
  807.  
  808.  
  809. disablemenus(disable)
  810. Boolean disable;
  811. {
  812.    disablemenuitem(disable,Menu_File,0);
  813.    disablemenuitem(disable,Menu_Edit,0);
  814.    disablemenuitem(disable,Menu_Find,0);
  815.    disablemenuitem(disable,Menu_Font,0);
  816.    disablemenuitem(disable,Menu_Option,0);
  817.    disablemenuitem(disable,Menu_Window,0);
  818.    disablemenuitem(disable,Menu_Project,0);
  819.    DrawMenuBar();
  820. }
  821.  
  822.  
  823. Handle HiddenMenuBar = NIL;
  824.  
  825. /* Hide all the menus -- used for graphics programs */
  826. HideMenus(hide)
  827. int hide;
  828. {
  829.   if(hide)
  830.     {
  831.       if(HiddenMenuBar != NIL)
  832.         DisposeHandle(HiddenMenuBar);
  833.       HiddenMenuBar = GetMenuBar();
  834.       ClearMenuBar();
  835.       DrawMenuBar();
  836.     }
  837.   else if(HiddenMenuBar != NIL)
  838.     {
  839.       SetMenuBar(HiddenMenuBar);
  840.       DisposeHandle(HiddenMenuBar);
  841.       HiddenMenuBar = NIL;
  842.       DrawMenuBar();
  843.     }
  844. }
  845.  
  846. /*
  847.   Choose the appropriate menu handler.
  848. */
  849.  
  850. #if !THINKC
  851. ProcPtr Mhandlers [] = 
  852. {
  853.   DoMenuApple, DoMenuFile,   DoMenuEdit,  DoMenuFind,
  854.   DoMenuFont,  DoMenuOption, DoMenuWindow, DoMenuProject
  855. };
  856.  
  857. #else
  858.  
  859. cfunc Mhandlers [] = 
  860. {
  861.   (cfunc) DoMenuApple,  (cfunc) DoMenuFile,  (cfunc) DoMenuEdit,
  862.   (cfunc) DoMenuFind,   (cfunc) DoMenuFont,  (cfunc) DoMenuOption,
  863.   (cfunc) DoMenuWindow, (cfunc) DoMenuProject
  864. };
  865. #endif
  866.  
  867.  
  868. Handle_Gofer_Menu(menu,item,modifiers)
  869. short   menu;
  870. short   item;
  871. short    modifiers;
  872. {
  873.   if(menu == kHMHelpMenuID)
  874.     DoMenuWindow(MItem_Help);
  875.  
  876.   /* Otherwise, if not a Gofer menu, just return */  
  877.   if(menu < MENUBASE || menu > Res_Menu_Project )
  878.     return;
  879.  
  880.   /* Flash Menu bar */
  881.   HiliteMenu(menu);
  882.  
  883.   if(thefrontwindow != ILLEGAL_WINDOW && TEHANDLE(thefrontwindow) != NIL)
  884.     TEDeactivate(TEHANDLE(thefrontwindow));
  885.     
  886.   (*Mhandlers[menu-MENUBASE])(item,modifiers);
  887.  
  888.   if(thefrontwindow != ILLEGAL_WINDOW && TEHANDLE(thefrontwindow) != NIL)
  889.     TEActivate(TEHANDLE(thefrontwindow));
  890.  
  891.   /* Disable highlighting unless we are quitting */   
  892.   if(!quit)
  893.     HiliteMenu(0);                               /* Turn menu selection off */
  894. } 
  895.  
  896.  
  897. Init_Gofer_Menus()
  898. {
  899.   MenuHandle Menu_Help;
  900.   extern short systemVersion;
  901.   
  902.   ClearMenuBar();
  903.  
  904.   Menu_Apple = GetMenu(Res_Menu_Apple);
  905.   InsertMenu (Menu_Apple,0);
  906.   AddResMenu(Menu_Apple,'DRVR');                      /* Insert any DAs */
  907.  
  908.   Menu_File = GetMenu(Res_Menu_File);
  909.   InsertMenu (Menu_File,0);
  910.  
  911.   Menu_Edit = GetMenu(Res_Menu_Edit);
  912.   InsertMenu (Menu_Edit,0);
  913.  
  914.   Menu_Find = GetMenu(Res_Menu_Find);
  915.   InsertMenu (Menu_Find,0);
  916.  
  917.   Menu_Font = GetMenu(Res_Menu_Font);
  918.   InsertMenu (Menu_Font,0);
  919.   AddResMenu (Menu_Font,'FONT');
  920.  
  921.   Menu_Option = GetMenu(Res_Menu_Options);
  922.   InsertMenu (Menu_Option,0);
  923.  
  924.   Menu_Window = GetMenu(Res_Menu_Window);
  925.   InsertMenu (Menu_Window,0);
  926.  
  927.   Menu_Project = GetMenu(Res_Menu_Project);
  928.   InsertMenu (Menu_Project,0);
  929.   insmenuitem(Menu_Project,"(-",PreludeItem-1);
  930.   
  931.   
  932.   if(systemVersion >= 0x0700 && HMGetHelpMenuHandle(&Menu_Help) == noErr && Menu_Help != NIL)
  933.     appendmenu(Menu_Help,"MacGofer Help");
  934.  
  935.   DrawMenuBar();                                      /* Draw the menu bar */
  936. }
  937.  
  938.  
  939. /*
  940.   Find a menu item for item in the range from..count
  941.   of the menu specified.
  942. */
  943.  
  944. short findmenuitem(menu,from,count,item)
  945. MenuHandle menu;
  946. int from, count;
  947. char *item;
  948. {
  949.   char menuname[256];
  950.   short i;
  951.   short max = CountMItems(menu);
  952.   
  953.   for (i=(short)from; i <= max && i <= (short) (from+count); ++i)
  954.     {
  955.        getitem(menu,(short)i,menuname);
  956.        if(strcmp(item,menuname)==0)
  957.          return(i);
  958.     }
  959.   return(-1);
  960. }
  961.  
  962.  
  963. SetModifiedMenus(modifiers)
  964. short modifiers;
  965. {
  966.    char *iconise = (modifiers & optionKey) ? "Iconise All…": 
  967.                    iconic(thefrontwindow)  ? "DeIconise":"Iconise";
  968.  
  969.    setitem( Menu_Window, MItem_Iconise, iconise);
  970. }
  971.